Highly-Concurrent Doubly-Linked Lists

As file systems are increasingly being deployed on ever larger systems with many cores and multi-gigabytes of memory, scaling the internal data structures of file systems has taken greater importance and urgency. A doubly-linked list is a simple and very commonly used data structure in file systems but it is not very friendly to multi-threaded use. While special cases of lists, such as queues and stacks, have lock-free versions that scale reasonably well, the general form of a doubly-linked list offers no such solution. Using a mutex to serialize all operations remains the de-facto method of maintaining a doubly linked list. This severely limits the scalability of the list and developers must resort to ad-hoc workarounds that involve using multiple smaller lists (with individual locks) and deal with the resulting complexity of the system. In this paper, we present an approach to building highly concurrent data structures, with special focus on the implementation of highly concurrent doubly-linked lists. Dubbed “advanced doubly-linked list” or “adlist” for short, our list allows iteration in any direction, and insert/delete operations over non-overlapping nodes to execute in parallel. Operations with common nodes get serialized so as to always present a locally consistent view to the callers. An adlist node needs an additional 8 bytes of space for keeping synchronization information – this is only possible due to the use of light-weight synchronization primitives called lwlocks which are optimized for small memory footprint. A read-write lwlock occupies 4 bytes, a mutex occupies 4 bytes, and a condition variable occupies 4 bytes. The corresponding primitives of the popular pthread library occupy 56, 40 and 48 bytes respectively on the x86-64 platform. The Data Domain File System makes extensive use of adlists which has allowed for significant scaling of the system without sacrificing simplicity.